/**
 * 密码管理器核心模块
 * 负责密码的添加、编辑、删除和搜索功能
 */
const PasswordManager = {
    // 当前的密码数据
    passwords: [],
    // 当前主密码
    currentMasterPassword: '',
    // 当前过滤的类别
    currentCategory: 'all',
    // 当前搜索关键词
    searchKeyword: '',

    /**
     * 初始化密码管理器，加载密码数据
     * @param {string} masterPassword - 主密码
     * @returns {boolean} - 初始化是否成功
     */
    init(masterPassword) {
        try {
            this.passwords = StorageModule.getPasswords(masterPassword);
            if (this.passwords === null) return false;
            
            this.currentMasterPassword = masterPassword;
            return true;
        } catch (e) {
            console.error('初始化密码管理器失败:', e);
            return false;
        }
    },

    /**
     * 获取所有密码
     * @returns {Array} - 密码数组
     */
    getAllPasswords() {
        return [...this.passwords];
    },

    /**
     * 获取过滤后的密码
     * @returns {Array} - 过滤后的密码数组
     */
    getFilteredPasswords() {
        let result = [...this.passwords];
        
        // 按类别过滤
        if (this.currentCategory !== 'all') {
            result = result.filter(p => p.category === this.currentCategory);
        }
        
        // 按搜索关键词过滤
        if (this.searchKeyword) {
            const keyword = this.searchKeyword.toLowerCase();
            result = result.filter(p => 
                p.name.toLowerCase().includes(keyword) || 
                p.username.toLowerCase().includes(keyword) || 
                (p.url && p.url.toLowerCase().includes(keyword)) ||
                (p.notes && p.notes.toLowerCase().includes(keyword))
            );
        }
        
        // 按修改时间排序（最新的在前面）
        result.sort((a, b) => {
            return new Date(b.lastModified) - new Date(a.lastModified);
        });
        
        return result;
    },

    /**
     * 获取单个密码
     * @param {number} id - 密码ID
     * @returns {Object|null} - 密码对象或null
     */
    getPassword(id) {
        return this.passwords.find(p => p.id === id) || null;
    },

    /**
     * 添加新密码
     * @param {Object} passwordData - 密码数据对象
     * @returns {boolean} - 添加是否成功
     */
    addPassword(passwordData) {
        try {
            const now = new Date().toISOString();
            const newPassword = {
                ...passwordData,
                id: Date.now(),
                created: now,
                lastModified: now
            };
            
            this.passwords.push(newPassword);
            return this.saveChanges();
        } catch (e) {
            console.error('添加密码失败:', e);
            return false;
        }
    },

    /**
     * 更新密码
     * @param {number} id - 密码ID
     * @param {Object} passwordData - 更新的密码数据
     * @returns {boolean} - 更新是否成功
     */
    updatePassword(id, passwordData) {
        try {
            // 确保id是数字类型
            id = parseInt(id);
            
            // 查找要更新的密码
            const index = this.passwords.findIndex(p => p.id === id);
            if (index === -1) {
                console.error('未找到要更新的密码:', id);
                return false;
            }
            
            // 保留原有的id和创建时间
            const now = new Date().toISOString();
            this.passwords[index] = {
                ...this.passwords[index],
                ...passwordData,
                id: id, // 确保ID保持不变
                lastModified: now
            };
            
            // 保存更改
            const success = this.saveChanges();
            if (!success) {
                console.error('保存密码更新失败');
                return false;
            }
            
            return true;
        } catch (e) {
            console.error('更新密码失败:', e);
            return false;
        }
    },

    /**
     * 删除密码
     * @param {number} id - 密码ID
     * @returns {boolean} - 删除是否成功
     */
    deletePassword(id) {
        try {
            const index = this.passwords.findIndex(p => p.id === id);
            if (index === -1) return false;
            
            this.passwords.splice(index, 1);
            return this.saveChanges();
        } catch (e) {
            console.error('删除密码失败:', e);
            return false;
        }
    },

    /**
     * 保存修改到本地存储
     * @returns {boolean} - 保存是否成功
     */
    saveChanges() {
        return StorageModule.savePasswords(this.passwords, this.currentMasterPassword);
    },

    /**
     * 设置过滤类别
     * @param {string} category - 类别
     */
    setCategory(category) {
        this.currentCategory = category;
    },

    /**
     * 设置搜索关键词
     * @param {string} keyword - 搜索关键词
     */
    setSearchKeyword(keyword) {
        this.searchKeyword = keyword;
    },

    /**
     * 获取密码过期状态
     * @param {Object} password - 密码对象
     * @returns {Object} - 密码过期状态对象 { expired: boolean, daysLeft: number }
     */
    getPasswordExpiryStatus(password) {
        // 默认密码有效期为90天
        const EXPIRY_DAYS = 90;
        
        if (!password.lastModified) return { expired: false, daysLeft: EXPIRY_DAYS };
        
        const lastModified = new Date(password.lastModified);
        const today = new Date();
        const diffTime = today - lastModified;
        const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24));
        
        return {
            expired: diffDays >= EXPIRY_DAYS,
            daysLeft: Math.max(0, EXPIRY_DAYS - diffDays)
        };
    },

    /**
     * 分析密码强度
     * @param {string} password - 密码字符串
     * @returns {string} - 强度等级："weak", "medium", "strong", "very-strong"
     */
    analyzePasswordStrength(password) {
        return CryptoModule.checkPasswordStrength(password);
    },

    /**
     * 生成新密码
     * @param {Object} options - 密码生成选项
     * @returns {string} - 生成的密码
     */
    generatePassword(options) {
        return CryptoModule.generatePassword(
            options.length || 12,
            {
                uppercase: options.uppercase !== false,
                lowercase: options.lowercase !== false,
                numbers: options.numbers !== false,
                symbols: options.symbols !== false
            }
        );
    },

    /**
     * 获取标记为已过期的密码列表
     * @returns {Array} - 过期的密码数组
     */
    getExpiredPasswords() {
        return this.passwords.filter(p => {
            const status = this.getPasswordExpiryStatus(p);
            return status.expired;
        });
    },

    /**
     * 登出 - 清除内存中的密码数据和主密码
     */
    logout() {
        this.passwords = [];
        this.currentMasterPassword = '';
        this.currentCategory = 'all';
        this.searchKeyword = '';
    }
}; 